What's New in Extensions
This page lists the API and manifest changes made in recent releases.
Google Chrome 84
New APIs
- declarativeNetRequest: The
chrome.declarativeNetRequestAPI is used to block or modify network requests by specifying declarative rules. This lets extensions modify network requests without intercepting them and viewing their content, thus providing more privacy.
Google Chrome 81
New APIs
- printing: Use the
chrome.printingAPI to send print jobs to printers installed on Chromebook.
Google Chrome 79
New APIs
- printingMetrics: Use the
chrome.printingMetricsAPI to fetch data about printing usage.
Google Chrome 78
New APIs
- loginState: Use the
chrome.loginStateAPI to read and monitor the login state.
Google Chrome 71
New APIs
- enterprise.hardwarePlatform: Use the
chrome.enterprise.hardwarePlatformAPI to get the manufacturer and model of the hardware platform where the browser runs. Note: This API is only available to extensions installed by enterprise policy.
Google Chrome 46
New APIs
- certificateProvider: Use this API to expose certificates to the platform which can use these certificates for TLS authentications.
- enterprise.deviceAttributes: Use the
chrome.enterprise.deviceAttributesAPI to read device attributes. Note: This API is only available to extensions force-installed by enterprise policy. - instanceID: Use
chrome.instanceIDto access the Instance ID service.
Google Chrome 45
New APIs
- platformKeys: Use the
chrome.platformKeysAPI to access client certificates managed by the platform. If the user or policy grants the permission, an extension can use such a certficate in its custom authentication protocol. E.g. this allows usage of platform managed certificates in third party VPNs (see chrome.vpnProvider).
Google Chrome 44
New APIs
- documentScan: Use the
chrome.documentScanAPI to discover and retrieve images from attached paper document scanners. - printerProvider: The
chrome.printerProviderAPI exposes events used by print manager to query printers controlled by extensions, to query their capabilities and to submit print jobs to these printers.
Google Chrome 43
New APIs
- vpnProvider: Use the
chrome.vpnProviderAPI to implement a VPN client. - networking.config: Use the
networking.configAPI to authenticate to captive portals.
Google Chrome 40
New APIs
- fileSystemProvider: Use the
chrome.fileSystemProviderAPI to create file systems, that can be accessible from the file manager on Chrome OS.
Google Chrome 39
New APIs
- extensionTypes: The
chrome.extensionTypesAPI contains type declarations for Chrome extensions.
Google Chrome 37
New APIs
- sessions: Use the
chrome.sessionsAPI to query and restore tabs and windows from a browsing session. - accessibilityFeatures: Use the
chrome.accessibilityFeaturesAPI to manage Chrome's accessibility features. This API relies on the ChromeSetting prototype of the type API for getting and setting individual accessibility features. In order to get feature states the extension must requestaccessibilityFeatures.readpermission. For modifying feature state, the extension needsaccessibilityFeatures.modifypermission. Note thataccessibilityFeatures.modifydoes not implyaccessibilityFeatures.readpermission. - enterprise.platformKeys: Use the
chrome.enterprise.platformKeysAPI to generate hardware-backed keys and to install certificates for these keys. The certificates will be managed by the platform and can be used for TLS authentication, network access or by other extension through chrome.platformKeys.
Google Chrome 35
New APIs
- system.storage: Use the
chrome.system.storageAPI to query storage device information and be notified when a removable storage device is attached and detached. - tts: Use the
chrome.ttsAPI to play synthesized text-to-speech (TTS). See also the related ttsEngine API, which allows an extension to implement a speech engine. - gcm: Use
chrome.gcmto enable apps and extensions to send and receive messages through the Google Cloud Messaging Service. - topSites: Use the
chrome.topSitesAPI to access the top sites (i.e. most visited sites) that are displayed on the new tab page. These do not include shortcuts customized by the user. - fontSettings: Use the
chrome.fontSettingsAPI to manage Chrome's font settings. - permissions: Use the
chrome.permissionsAPI to request declared optional permissions at run time rather than install time, so users understand why the permissions are needed and grant only those that are necessary. - identity: Use the
chrome.identityAPI to get OAuth2 access tokens. - input.ime: Use the
chrome.input.imeAPI to implement a custom IME for Chrome OS. This allows your extension to handle keystrokes, set the composition, and manage the candidate window. - devtools.panels: Use the
chrome.devtools.panelsAPI to integrate your extension into Developer Tools window UI: create your own panels, access existing panels, and add sidebars. - browsingData: Use the
chrome.browsingDataAPI to remove browsing data from a user's local profile. - fileBrowserHandler: Use the
chrome.fileBrowserHandlerAPI to extend the Chrome OS file browser. For example, you can use this API to enable users to upload files to your website. - devtools.inspectedWindow: Use the
chrome.devtools.inspectedWindowAPI to interact with the inspected window: obtain the tab ID for the inspected page, evaluate the code in the context of the inspected window, reload the page, or obtain the list of resources within the page. - power: Use the
chrome.powerAPI to override the system's power management features. - devtools.network: Use the
chrome.devtools.networkAPI to retrieve the information about network requests displayed by the Developer Tools in the Network panel. - proxy: Use the
chrome.proxyAPI to manage Chrome's proxy settings. This API relies on the ChromeSetting prototype of the type API for getting and setting the proxy configuration. - commands: Use the commands API to add keyboard shortcuts that trigger actions in your extension, for example, an action to open the browser action or send a command to the extension.
- extension: The
chrome.extensionAPI has utilities that can be used by any extension page. It includes support for exchanging messages between an extension and its content scripts or between extensions, as described in detail in Message Passing. - pageCapture: Use the
chrome.pageCaptureAPI to save a tab as MHTML. - runtime: Use the
chrome.runtimeAPI to retrieve the background page, return details about the manifest, and listen for and respond to events in the app or extension lifecycle. You can also use this API to convert the relative path of URLs to fully-qualified URLs. - debugger: The
chrome.debuggerAPI serves as an alternate transport for Chrome's remote debugging protocol. Usechrome.debuggerto attach to one or more tabs to instrument network interaction, debug JavaScript, mutate the DOM and CSS, etc. Use the DebuggeetabIdto target tabs with sendCommand and route events bytabIdfrom onEvent callbacks. - browserAction: Use browser actions to put icons in the main Google Chrome toolbar, to the right of the address bar. In addition to its icon, a browser action can have a tooltip, a badge, and a popup.
- webRequest: Use the
chrome.webRequestAPI to observe and analyze traffic and to intercept, block, or modify requests in-flight. - bookmarks: Use the
chrome.bookmarksAPI to create, organize, and otherwise manipulate bookmarks. Also see Override Pages, which you can use to create a custom Bookmark Manager page. - management: The
chrome.managementAPI provides ways to manage the list of extensions/apps that are installed and running. It is particularly useful for extensions that override the built-in New Tab page. - privacy: Use the
chrome.privacyAPI to control usage of the features in Chrome that can affect a user's privacy. This API relies on the ChromeSetting prototype of the type API for getting and setting Chrome's configuration. - desktopCapture: Desktop Capture API that can be used to capture content of screen, individual windows or tabs.
- declarativeContent: Use the
chrome.declarativeContentAPI to take actions depending on the content of a page, without requiring permission to read the page's content. - tabCapture: Use the
chrome.tabCaptureAPI to interact with tab media streams. - notifications: Use the
chrome.notificationsAPI to create rich notifications using templates and show these notifications to users in the system tray. - i18n: Use the
chrome.i18ninfrastructure to implement internationalization across your whole app or extension. - idle: Use the
chrome.idleAPI to detect when the machine's idle state changes. - contentSettings: Use the
chrome.contentSettingsAPI to change settings that control whether websites can use features such as cookies, JavaScript, and plugins. More generally speaking, content settings allow you to customize Chrome's behavior on a per-site basis instead of globally. - history: Use the
chrome.historyAPI to interact with the browser's record of visited pages. You can add, remove, and query for URLs in the browser's history. To override the history page with your own version, see Override Pages. - tabs: Use the
chrome.tabsAPI to interact with the browser's tab system. You can use this API to create, modify, and rearrange tabs in the browser. - system.memory: The
chrome.system.memoryAPI. - contextMenus: Use the
chrome.contextMenusAPI to add items to Google Chrome's context menu. You can choose what types of objects your context menu additions apply to, such as images, hyperlinks, and pages. - storage: Use the
chrome.storageAPI to store, retrieve, and track changes to user data. - omnibox: The omnibox API allows you to register a keyword with Google Chrome's address bar, which is also known as the omnibox.
- ttsEngine: Use the
chrome.ttsEngineAPI to implement a text-to-speech(TTS) engine using an extension. If your extension registers using this API, it will receive events containing an utterance to be spoken and other parameters when any extension or Chrome App uses the tts API to generate speech. Your extension can then use any available web technology to synthesize and output the speech, and send events back to the calling function to report the status. - events: The
chrome.eventsnamespace contains common types used by APIs dispatching events to notify you when something interesting happens. - downloads: Use the
chrome.downloadsAPI to programmatically initiate, monitor, manipulate, and search for downloads. - wallpaper: Use the
chrome.wallpaperAPI to change the ChromeOS wallpaper. - system.cpu: Use the
system.cpuAPI to query CPU metadata. - types: The
chrome.typesAPI contains type declarations for Chrome. - windows: Use the
chrome.windowsAPI to interact with browser windows. You can use this API to create, modify, and rearrange windows in the browser. - pageAction: Use the
chrome.pageActionAPI to put icons in the main Google Chrome toolbar, to the right of the address bar. Page actions represent actions that can be taken on the current page, but that aren't applicable to all pages. Page actions appear grayed out when inactive. - alarms: Use the
chrome.alarmsAPI to schedule code to run periodically or at a specified time in the future.
Google Chrome 22
Additions to existing APIs
- Background pages can optionally be non-persistent, using a feature we call
event pages. Event pages run only while they're being used, and will unload when idle to save resources.
Google Chrome 21
Additions to existing APIs
- The types.ChromeSetting.set method now has a
regular_onlyscope. - The browsingData.RemovalOptions now has an
originTypesproperty. - The management.uninstall method now has a
showConfirmDialogparameter. - The contextMenus.create method now allows you to specify unique IDs for each item. This is intended to be used with the new
contextMenus.onClickedevent, to distinguish the clicked item. - The browserAction.setIcon and pageAction.setIcon methods now accept optional callbacks.
- The privacy.websites namespace now has a
protectedContentEnabledproperty. - The
indexparameter to the tabs.move method now accepts -1 to indicate that the tab should be placed at the end. - The
windowIdparameter to the tabs.highlight method is now optional.
Google Chrome 20
Additions to existing APIs
- The chrome.contextMenus contextMenus.create and contextMenus.update methods now have an
enabledparameter. - The privacy API's privacy.services object now has a
spellingServiceEnabledsetting. - The chrome.tabs tabs.executeScript and tabs.insertCSS now accept a runAt parameter.
- The
sendRequest()method has been deprecated in favor of thesendMessage()method for both the runtime.sendMessage and tabs.sendMessage.
Manifest changes
- Manifest version 1 was deprecated in Chrome 18 and will be phased out according to the Manifest version 1 support
Google Chrome 19
Additions to existing APIs
- The window API's windows.Window object now has an
alwaysOnTopproperty and supports the fullscreen state. - The
chrome.tabstabs.query method now has thecurrentWindowandlastFocusedWindowparameters. - The browser action API has the following new getter functions: browserAction.getTitle, browserAction.getBadgeText, browserAction.getBadgeBackgroundColor, and browserAction.getPopup.
- The page action API has the following new getter functions: pageAction.getTitle and pageAction.getPopup.
Google Chrome 18
Additions to existing APIs
- The chrome.tabs tabs.create and tabs.update methods now have an
openerTabIdparameter
Manifest changes
- The new manifest version field specifies the version of the manifest that your package requires. As of Chrome 18, you should use manifest version 2.
- The new Content Security Policy (CSP) field is used to define an extension's policies towards the types of content that can be loaded and executed by the extension.
- Most background pages only include a list of script files. For these background pages, you can use the new background.scripts property and Chrome will generate a background page for you.
- The new web_accessible_resources field specifies the paths of packaged resources that are expected to be usable in the context of a web page.
Google Chrome 17
Additions to existing APIs
- The management API's management.ExtensionInfo object now has a
disabledReasonproperty. - The omnibox API now works in split incognito mode.
Manifest changes
- Permissions can be optional for the content setting API, the web navigation API, and the new web request API.
Google Chrome 16
Additions to existing APIs
- The new tabs.query method gets all tabs that have the specified properties or all tabs if no properties are specified.
- The new tabs.reload method reloads a tab and includes the option to preserve the local cache of the reloaded tab.
- The management API's management.ExtensionInfo object now has an
updateURLproperty. - You can now limit the supported locales for an external extension by adding the
supported_localesattribute to theexternal_extensions.json. - The methods
getAllInWindow()andgetSelected()have been deprecated. To get details about all tabs in the specified window, use tabs.query with the argument {'windowId': windowId}. To get the tab that is selected in the specified window, usechrome.tabs.query()with the argument{'active': true}. - You are no longer required to specify the
tabIdfor the tabs.update method. When not provided, the tabId defaults to the selected tab of the current window. - External extension files on Mac OS can now be owned by users within a wheel group (or an admin group).
- Experimental permission for deprecated windows.create panel type.
Manifest changes
- The new requirements field allows you to declare extension requirements up front. For example, you can use this field to specify that your app requires 3D graphics support in order to use features such as CSS 3D Tranforms or WebGL.
Google Chrome 15
Additions to existing APIs
- You can retrieve permission warnings using the new management API methods management.getPermissionWarningsById and management.getPermissionWarningsByManifest.
- The management API’s management.ExtensionInfo object has a new field, offlineEnabled.
- You can now internationalize content script CSS files by using __MSG_messagename__ placeholders.
- The callback for the tabs.update method is passed null instead of the tab details if the extension does not have the tabs permission.
Manifest changes
- The new offline_enabled field lets you specify that your app works well even without an internet connection.
Google Chrome 14
Additions to existing APIs
- An optional drawAttention field in windows.update's updateInfo object lets you specify that the window should entice the user to change focus to it.
- The new bookmarks.getSubTree function lets you retrieve just part of the Bookmarks hierarchy
- The tabs permission is no longer required for tabs.remove and tabs.onRemoved.
Manifest changes
- The new content_security_policy field can help prevent cross-site scripting vulnerabilities in your extension.
- The new nacl_modules field lets you register Native Client modules as content handlers for MIME types.
Google Chrome 13
Additions to existing APIs
- Content scripts can now make cross-origin XMLHttpRequests to the same sites that their parent extension can, eliminating the need to relay these requests through a background page.
- You can now use
@run-atin an imported Greasemonkey script to control when the script is injected. It works the same way asrun_atin content scripts.
Manifest changes
- A new
exclude_matchesitem in the content_scripts field lets you target your content script more precisely. For details, see Match patterns and globs. - New clipboardRead and clipboardWrite permissions specify capabilities for
document.execCommand().
Google Chrome 12
Additions to existing APIs
- Two new
chrome.extensionmethods—extension.isAllowedFileSchemeAccess and extension.isAllowedIncognitoAccess—let you determine whether your extension has increased access, which the user specifies using the extensions management page (chrome://extensions). - The windows.create method can now take a
focusedvalue. Previously, all new windows had the keyboard focus; now you can create windows without interrupting the user's typing. - If the manifest specifies experimental permission, your extension can specify panel as the value of the
typefield in the windows.create method or the windows.Window type. - The
chrome.contextMenuscontextMenus.create and contextMenus.update methods now let you specify a context value of frame
Google Chrome 11
Additions to existing APIs
- For security reasons, you can no longer call tabs.captureVisibleTab on just any tab. Instead, you now must have host permission for the URL displayed by that tab. To get the previous behavior, specify
for the host permission. - The management API's management.ExtensionInfo object now has a
homepageUrlproperty. - The management API now lets you get the icons of disabled apps and extensions. Also, you can now modify the regular icon's URL to get its disabled equivalent. See management.IconInfo for details.
Google Chrome 10
Additions to existing APIs
- The windows.create method now has a
tabIdfield. You can use it to move a tab or panel into a new window.
Manifest changes
- The new background permission extends the life of Chrome, allowing your extension or app to run even when Chrome has no windows open.
Google Chrome 9
Additions to existing APIs
- The tabs.Tab object now has a
pinnedproperty that's reflected in variouschrome.tabsmethods. For example, you can tabs.create a pinned tab. - The windows.create method can now take a list of URLs, letting you create multiple tabs in the new window.
- The new management.get method lets you get information about the specified extension or app.
Manifest changes
- The homepage_url field lets you specify the extension or app's homepage.
Google Chrome 7
Manifest changes
- Introduced split incognito mode as the default for installable web apps (also available to extensions).
- The tabs API
create()andupdate()methods no longer require the tabs permission, removing one common cause of scary dialogs.
Google Chrome 6
Additions to existing APIs
- The extension.getViews method can now return popup views.
- A new windows.WINDOW_ID_NONE constant identifies when focus shifts away from the browser.
- The new tabs.getCurrent method returns the tab associated with the currently executing script.
Manifest changes
- The geolocation permission gives an extension access to the user's physical location.
- Match patterns can now select all schemes or all URLs.
- Access to file:/// URLs no longer triggers the access to your machine security warning, but now requires user opt-in from the extensions management page.